// pages/nametest/nametest.js
const cnchar = require('cnchar');
const wuxingUtil = require('../../utils/wuxing');
const nameApi = require('../../utils/api');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 当前步骤：input, dimensions, bazi, result
    currentStep: 'input',
    
    // 输入页面数据
    name: '',
    surname: '', // 新增姓氏字段
    givenName: '', // 新增名字字段
    gender: '男',
    
    // 时间控制相关
    currentDateTimestamp: null, // 当前日期时间戳
    releaseDateTimestamp: null, // 发布日期时间戳
    
    // 维度选择页面数据
    selectedDimensions: [],
    dimensionMap: {}, // 添加维度映射对象，用于在WXML中判断选中状态
    
    // 喜用神页面数据
    selectedElements: [], // 改为数组，支持多选
    showBirthTimeForm: false, // 是否显示生辰输入表单
    birthDate: '', // 出生日期
    birthTime: '', // 出生时间
    baziResult: {  // 八字计算结果
      pillars: [], // 四柱
      elements: [], // 四柱对应的五行
      favElements: [] // 喜用神
    },
    
    // 结果页面数据
    result: {
      score: 92,
      dimensionScores: [
        { id: 'pronunciation', name: '发音', score: 94, icon: '🔊' },
        { id: 'shape', name: '字形', score: 88, icon: '📝' },
        { id: 'meaning', name: '寓意', score: 95, icon: '💭' },
        { id: 'gender', name: '性别匹配', score: 90, icon: '⚧' }
      ],
      analysis: [
        { 
          title: '发音分析', 
          content: '"李思维"发音优美，声调为阳平-阳平-阳平，声调搭配和谐，朗朗上口。"思维"二字音韵优美，没有不良谐音，整体发音流畅自然。',
          icon: '🔊'
        },
        { 
          title: '字形分析', 
          content: '"李"为常用字，笔画简洁；"思"字中等复杂度，"维"字笔画适中。整体字形美观，无过于复杂的字，书写方便。三个字的结构搭配协调，视觉效果平衡。',
          icon: '📝'
        },
        { 
          title: '寓意分析', 
          content: '"思"表示思考、思想；"维"表示维系、思维方式。"思维"二字组合寓意深思熟虑、头脑灵活、思维敏捷，暗示人聪明智慧、有条理性。非常积极向上的寓意。',
          icon: '💭'
        },
        { 
          title: '性别匹配度', 
          content: '"思维"一名既有阳刚之气，又不失细腻，对于男性而言非常适合。名字既不过分阴柔，也不过于强硬，给人理性、睿智的印象，非常符合现代男性形象。',
          icon: '⚧'
        }
      ],
      suggestion: '"李思维"是一个非常优秀的名字选择，各方面评分都很高。这个名字寓意美好，发音流畅，字形美观，契合命理，性别匹配度高。建议您可以放心使用此名，它将为您的未来带来积极的影响。'
    },
    
    // 广告和计算相关状态
    isCalculating: false,
    adCompleted: false,
    apiCompleted: false,
    apiResult: null,
    messageTimers: {
      firstTimer: null,
      interval: null
    },
    
    // 维度详情查看的广告控制
    detailAdCompleted: false, // 是否已经完成观看广告
    pendingDetailId: null, // 等待查看详情的维度ID
    currentNameSession: '', // 当前姓名会话标识，用于区分不同名字的测试
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 可以从options获取初始参数
    this.updateDimensionMap();
    
    // 创建激励广告实例
    this.createRewardedVideoAd();
    
    // 创建详情查看激励广告实例
    this.createDetailRewardedVideoAd();

    // 获取当前日期
    const today = new Date();
    
    // 设置当前日期时间戳
    const currentDateTimestamp = today.getTime();
    
    // 设置发布日期为2025年6月4日中午12点，6是7月，6是6日
    const releaseDate = new Date(2025, 6, 7);
    releaseDate.setHours(9, 0, 0, 0); // 设置为下午17点
    const releaseDateTimestamp = releaseDate.getTime();
    
    // 打印日期信息，用于调试
    console.log('当前日期时间戳:', currentDateTimestamp);
    console.log('当前日期:', today.toISOString());
    console.log('发布日期时间戳:', releaseDateTimestamp);
    console.log('发布日期:', releaseDate.toISOString());
    console.log('比较结果 currentDateTimestamp > releaseDateTimestamp:', currentDateTimestamp > releaseDateTimestamp);
    
    this.setData({
      currentDateTimestamp,
      releaseDateTimestamp
    });
    
    // 移除不可用的维度
    this.removeUnavailableDimensions();
  },

  /**
   * 移除不可用的维度
   */
  removeUnavailableDimensions() {
    const { currentDateTimestamp, releaseDateTimestamp, selectedDimensions } = this.data;
    
    console.log('removeUnavailableDimensions - 当前日期时间戳:', currentDateTimestamp);
    console.log('removeUnavailableDimensions - 发布日期时间戳:', releaseDateTimestamp);
    console.log('removeUnavailableDimensions - 比较结果:', currentDateTimestamp > releaseDateTimestamp);
    
    // 如果当前日期不大于发布日期（中午12点），则从选中维度中移除favElement
    if (!(currentDateTimestamp > releaseDateTimestamp) && selectedDimensions.includes('favElement')) {
      console.log('需要移除喜用神维度 - 当前时间未到发布时间点');
      const updatedDimensions = selectedDimensions.filter(dim => dim !== 'favElement');
      this.setData({
        selectedDimensions: updatedDimensions
      }, () => {
        // 更新维度映射
        this.updateDimensionMap();
      });
    } else {
      console.log('不需要移除喜用神维度 - 当前时间已超过发布时间点或未选择喜用神维度', selectedDimensions);
    }
  },

  // 更新维度映射，用于WXML中判断选中状态
  updateDimensionMap() {
    const dimensionMap = {};
    const { selectedDimensions } = this.data;
    
    // 根据选择的维度数量确定权重分配
    let weights = [];
    
    switch(selectedDimensions.length) {
      case 1:
        weights = [100];
        break;
      case 2:
        weights = [70, 30];
        break;
      case 3:
        weights = [50, 30, 20];
        break;
      case 4:
        weights = [40, 30, 20, 10];
        break;
      case 5:
        weights = [30, 25, 20, 15, 10];
        break;
      default:
        weights = [];
    }
    
    // 创建选中状态映射，并添加权重
    selectedDimensions.forEach((id, index) => {
      dimensionMap[id] = {
        selected: true,
        rank: index + 1,
        weight: weights[index] || 0
      };
    });
    
    this.setData({ dimensionMap });
  },

  // ========== 输入页面方法 ==========
  
  /**
   * 输入姓氏处理函数
   */
  onSurnameInput(e) {
    const surname = e.detail.value;
    this.setData({
      surname,
      name: surname + this.data.givenName
    });
  },
  
  /**
   * 输入名字处理函数
   */
  onGivenNameInput(e) {
    const givenName = e.detail.value;
    this.setData({
      givenName,
      name: this.data.surname + givenName
    });
  },

  /**
   * 选择性别处理函数
   */
  onGenderSelect(e) {
    this.setData({
      gender: e.currentTarget.dataset.gender
    });
  },

  /**
   * 前往维度选择页面
   */
  goToDimensions() {
    // 确保已填写姓氏和名字
    if (!this.data.surname || !this.data.givenName) {
      wx.showToast({
        title: '请输入完整姓名',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      currentStep: 'dimensions'
    });
  },

  // ========== 维度选择页面方法 ==========
  
  /**
   * 切换选择维度
   */
  toggleDimension(e) {
    const id = e.currentTarget.dataset.id;
    let selectedDimensions = [...this.data.selectedDimensions];
    
    if (selectedDimensions.includes(id)) {
      // 如果已选中，则移除
      selectedDimensions = selectedDimensions.filter(item => item !== id);
    } else {
      // 如果未选中且未达到上限，则添加
      if (selectedDimensions.length < 5) {
        selectedDimensions.push(id);
      } else {
        wx.showToast({
          title: '最多选择5个维度',
          icon: 'none'
        });
        return;
      }
    }
    
    this.setData({ selectedDimensions }, () => {
      // 更新维度映射
      this.updateDimensionMap();
    });
  },
  
  /**
   * 判断维度是否已选中 - 不再直接在WXML中调用
   */
  isSelectedDimension(id) {
    return this.data.selectedDimensions.includes(id);
  },
  
  /**
   * 获取维度排序号 - 不再直接在WXML中调用
   */
  getDimensionRank(id) {
    const index = this.data.selectedDimensions.indexOf(id);
    return index === -1 ? 0 : index + 1;
  },
  
  /**
   * 前往下一步（喜用神或结果页面）
   */
  goToNextStep() {
    // 获取是否来自喜用神页面的标记
    const fromBaziNext = wx.getStorageSync('fromBaziNext') || false;
    
    // 如果选择了喜用神维度且当前日期大于发布日期（中午12点），且不是从喜用神页面点击下一步来的，则前往喜用神页面
    if (this.data.selectedDimensions.includes('favElement') && 
        this.data.currentDateTimestamp > this.data.releaseDateTimestamp && 
        !fromBaziNext) {
      console.log('前往喜用神页面 - 当前时间已超过发布时间点');
      this.setData({
        currentStep: 'bazi'
      });
    } else {
      // 清除标记
      wx.removeStorageSync('fromBaziNext');
      
      // 需要计算分数并前往结果页面，先提示播放广告
      wx.showModal({
        title: '测算结果',
        content: '✨ 为了提供更专业的分析服务，邀请您观看一小段广告，完成后即可获取测名结果。感谢您的支持，这帮助我们持续优化服务质量！',
        success: (res) => {
          if (res.confirm) {
            // 用户同意观看广告，开始计算分数流程
            this.startScoreCalculation();
          } else {
            // 用户拒绝观看广告，中断流程
            console.log('用户拒绝观看广告');
          }
        }
      });
    }
  },
  
  /**
   * 返回输入页面
   */
  backToInput() {
    this.setData({
      currentStep: 'input',
      // 重置输入数据
      name: '',
      surname: '',
      givenName: '',
      gender: '男',
      // 重置维度选择
      selectedDimensions: [],
      dimensionMap: {},
      // 重置喜用神数据
      selectedElements: [],
      showBirthTimeForm: false,
      birthDate: '',
      birthTime: '',
      baziResult: {
        pillars: [],
        elements: [],
        favElements: []
      },
      calculatedElements: false,
      // 重置广告相关状态
      detailAdCompleted: false,
      pendingDetailId: null,
      currentNameSession: ''
    }, () => {
      // 更新维度映射
      this.updateDimensionMap();
    });
    
    // 清空本地存储中可能存在的会话记录
    let completedSessions = wx.getStorageSync('detailAdCompletedSessions') || [];
    if (completedSessions.length > 20) { // 避免本地存储无限增长，只保留最近20条记录
      completedSessions = completedSessions.slice(-20);
      wx.setStorageSync('detailAdCompletedSessions', completedSessions);
    }
  },

  // ========== 喜用神页面方法 ==========
  
  /**
   * 切换显示生辰信息表单
   */
  toggleBirthTimeForm() {
    const showBirthTimeForm = !this.data.showBirthTimeForm;
    
    // 不再清空已选择的元素
    this.setData({
      showBirthTimeForm
    });
  },
  
  /**
   * 出生日期改变处理
   */
  onBirthDateChange(e) {
    this.setData({
      birthDate: e.detail.value
    });
  },
  
  /**
   * 出生时间改变处理
   */
  onBirthTimeChange(e) {
    this.setData({
      birthTime: e.detail.value
    });
  },
  
  /**
   * 计算八字和喜用神
   */
  calculateBaziElements() {
    const { birthDate, birthTime } = this.data;
    
    if (!birthDate || !birthTime) {
      wx.showToast({
        title: '请选择完整的出生日期和时间',
        icon: 'none'
      });
      return;
    }
    
    wx.showLoading({
      title: '正在查询...'
    });
    
    // 解析出生时间
    const [year, month, day] = birthDate.split('-');
    const [hour, minute] = birthTime.split(':');
    
    // 获取性别数据
    const sex = this.data.gender === '男' ? 1 : 0;
    
    // 调用API
    wx.request({
      url: `https://yisuan.net/app/bazi-wuxing`,
      data: {
        _year: year,
        _month: month,
        _day: day,
        _hour: hour,
        _sex: sex
      },
      success: (res) => {
        const html = res.data;
        try {
          // 解析HTML
          const result = this.parseHTML(html);
          
          // 解析数据
          const baziParts = result.bazi.split('、');
          
          // 提取喜用神
          const favElements = this.extractFavElements(result.xiyongshen);
          
          // 设置八字结果
          const baziResult = {
            pillars: [
              baziParts[0] || '',
              baziParts[1] || '',
              baziParts[2] || '',
              baziParts[3] || ''
            ],
            elements: result.wuxing.split('、'),
            favElements: favElements
          };
          
          // 自动选择喜用神元素
          this.setData({
            baziResult,
            showBaziResult: true,
            selectedElements: favElements, // 自动设置喜用神元素
            calculatedElements: true // 标记为已通过计算得到喜用神
          });
          
          // 隐藏加载提示
          wx.hideLoading();
          
          wx.showToast({
            title: '分析完成',
            icon: 'success'
          });
          
        } catch (error) {
          console.error('解析结果失败:', error);
          // 隐藏加载提示
          wx.hideLoading();
          
          wx.showToast({
            title: '获取数据信息失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求API失败:', err);
        // 隐藏加载提示
        wx.hideLoading();
        
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      },
      complete: () => {
        // 确保在任何情况下都隐藏加载提示
        wx.hideLoading();
      }
    });
  },
  
  /**
   * HTML解析方法
   */
  parseHTML(html) {
    // 解析基本信息
    const baziReg = /<tr class="has-background-warning">[\s\S]*?<td><b>八字<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const baziMatch = html.match(baziReg);
    const bazi = baziMatch ? 
      [baziMatch[1], baziMatch[2], baziMatch[3], baziMatch[4]].join('、') : 
      '未找到数据信息';
  
    // 解析汉字属性信息
    const wuxingReg = /<tr class="has-background-warning">[\s\S]*?<td><b>五行<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const wuxingMatch = html.match(wuxingReg);
    const wuxing = wuxingMatch ? 
      [wuxingMatch[1], wuxingMatch[2], wuxingMatch[3], wuxingMatch[4]].join('、') : 
      '未找到汉字属性信息';
  
    // 解析推荐用字
    const xiyongReg = /<h3>喜用神：<\/h3>([^<]+)/;
    const xiyongshenMatch = html.match(xiyongReg);
    const xiyongshen = xiyongshenMatch ? 
      xiyongshenMatch[1].replace(/<br>/, '').trim() : 
      '未找到推荐用字';
  
    // 解析评分数据
    const scoreMap = {};
    const scoreReg = /<label><b>(金|木|水|火|土)：([\d.]+)<\/b><\/label>/g;
    let scoreMatch;
    
    while ((scoreMatch = scoreReg.exec(html)) !== null) {
      const [_, element, value] = scoreMatch;
      scoreMap[element] = parseFloat(value);
    }
  
    // 确保完整数据（包含可能缺失的元素）
    ['金','木','水','火','土'].forEach(e => {
      if (!scoreMap.hasOwnProperty(e)) scoreMap[e] = 0;
    });
  
    // 按得分降序排序并格式化
    const sortedScores = Object.entries(scoreMap)
      .sort((a, b) => b[1] - a[1])
      .map(([k, v]) => `${k}：${v.toFixed(3)}`)
      .join('，');
  
    return {
      bazi: bazi,
      wuxing: wuxing,
      xiyongshen: xiyongshen,
      lianghua: sortedScores || '未找到评分数据'
    };
  },
  
  /**
   * 从喜用神提取五行元素
   */
  extractFavElements(xiyongshen) {
    if (!xiyongshen) return [];
    
    // 提取喜用神中的五行元素
    const elements = [];
    const wuxingChars = ['金', '木', '水', '火', '土'];
    
    // 从字符串中提取所有元素
    for (const char of xiyongshen) {
      if (wuxingChars.includes(char) && !elements.includes(char)) {
        elements.push(char);
      }
    }
    
    // 如果没有找到元素，提供一个默认值
    return elements.length > 0 ? elements : ['金', '木', '水', '火', '土'];
  },
  
  /**
   * 选择元素（支持多选）
   */
  toggleElement(e) {
    // 如果已经通过八字计算得到了喜用神，不允许再修改
    if (this.data.calculatedElements) {
      wx.showToast({
        title: '已通过八字查询，不可更改',
        icon: 'none'
      });
      return;
    }
    
    const element = e.currentTarget.dataset.element;
    let selectedElements = [...this.data.selectedElements];
    
    if (selectedElements.includes(element)) {
      // 如果已选中，则移除
      selectedElements = selectedElements.filter(item => item !== element);
    } else {
      // 如果未选中，则添加
      selectedElements.push(element);
    }
    
    this.setData({
      selectedElements
    });
  },
  
  /**
   * 选择计算得到的喜用神元素
   */
  selectCalculatedElement(e) {
    // 如果已经通过八字计算得到了喜用神，不允许再修改
    if (this.data.calculatedElements) {
      wx.showToast({
        title: '已通过八字查询，不可更改',
        icon: 'none'
      });
      return;
    }
    
    const element = e.currentTarget.dataset.element;
    let selectedElements = [...this.data.selectedElements];
    
    // 如果元素已选中，则不重复添加
    if (!selectedElements.includes(element)) {
      selectedElements.push(element);
      
      this.setData({
        selectedElements
      });
      
      wx.showToast({
        title: `已添加${element}元素`,
        icon: 'success'
      });
    }
  },
  
  /**
   * 移除已选元素
   */
  removeElement(e) {
    // 如果已经通过八字计算得到了喜用神，不允许再修改
    if (this.data.calculatedElements) {
      wx.showToast({
        title: '已通过八字查询，不可更改',
        icon: 'none'
      });
      return;
    }
    
    const element = e.currentTarget.dataset.element;
    const selectedElements = this.data.selectedElements.filter(item => item !== element);
    
    this.setData({
      selectedElements
    });
  },
  
  /**
   * 获取元素对应的图标
   */
  getElementEmoji(element) {
    const emojiMap = {
      '金': '💰',
      '木': '🌳',
      '水': '💧',
      '火': '🔥',
      '土': '⛰️'
    };
    return emojiMap[element] || '';
  },
  
  /**
   * 返回维度选择页面
   */
  backToDimensions() {
    this.setData({
      currentStep: 'dimensions'
    });
  },
  
  /**
   * 前往结果页面
   */
  goToResult() {
    // 确保已选择喜用神元素
    if (this.data.selectedElements.length === 0) {
      wx.showToast({
        title: '请选择至少一个喜用神元素',
        icon: 'none'
      });
      return;
    }
    
    // 直接更新全局数据，确保在结果页面能够访问
    wx.setStorageSync('selectedElements', this.data.selectedElements);
    
    // 添加标记，表示用户已经从喜用神页面点击了下一步，避免再次跳转回喜用神页面
    wx.setStorageSync('fromBaziNext', true);
    
    // 计算分数前回到维度选择界面，然后通过goToNextStep方法进入结果页面
    this.setData({
      currentStep: 'dimensions'
    }, () => {
      this.goToNextStep();
    });
  },

  // ========== 结果页面方法 ==========
  
  /**
   * 根据分数获取评价文本
   */
  getSummaryText(score) {
    if (score >= 90) return '非常适合';
    if (score >= 80) return '比较适合';
    if (score >= 70) return '基本适合';
    if (score >= 60) return '一般适合';
    return '不太适合';
  },
  
  /**
   * 判断字符是否为生僻字
   * @param {string} char 单个字符
   * @returns {boolean} 是否为生僻字
   */
  isRareCharacter(char) {
    const charCode = char.charCodeAt(0);
    if (!(charCode >= 0x4e00 && charCode <= 0x9fa5)) {
        return true;
    }
    const strokeCount = cnchar.stroke(char);
    if(strokeCount === 0) {
        return true;
    }
    return false;
  },
  
  /**
   * 判断字符是否是复杂字（笔画数量大于15）
   * @param {string} char - 单个字符
   * @returns {boolean} - 是否是复杂字
   */
  isComplexCharacter(char) {
    try {
      // 尝试使用cnchar库获取笔画数
      const strokeCount = cnchar.stroke(char);
      console.log(`字符 ${char} 的笔画数: ${strokeCount}`);
      
      // 笔画数大于15判定为复杂字
      const isComplex = strokeCount > 15;
      console.log(`字符 ${char} 是否复杂字 (笔画数${strokeCount}): ${isComplex ? '是' : '否'}`);
      return isComplex;
    } catch (error) {
      console.error('cnchar库调用失败:', error);
      // 当cnchar库调用失败时，使用备用方案
      return this.isComplexCharacterFallback(char);
    }
  },
  
  // 备用方案
  isComplexCharacterFallback(char) {
    const strokeData = {
      '一': 1, '二': 2, '三': 3, '人': 2, '口': 3, '日': 4, '月': 4, '木': 4,
      '水': 4, '火': 4, '土': 3, '金': 8, '山': 3, '石': 5, '田': 5, '白': 5,
      '王': 4, '正': 5, '生': 5, '子': 3, '女': 3, '好': 6, '林': 8, '心': 4,
      '李': 7, '何': 7, '张': 11, '王': 4, '赵': 9, '钱': 10, '孙': 10, '刘': 8,
      '思': 9, '维': 14, '明': 8, '亮': 9, '华': 6, '强': 11, '文': 4, '平': 5,
      '龙': 16, '龟': 16, '鑫': 24, '爨': 30, '籍': 20, '麟': 23, '鳞': 23,
      '馨': 20, '鹭': 24, '髓': 22, '鬣': 25, '麒': 19, '鼎': 13, '齐': 14,
      '森': 12, '淼': 12, '焱': 12, '垚': 12, '炎': 8, '煊': 13, '琳': 12,
      '璐': 15, '瑞': 14, '瑾': 16, '璟': 16, '玥': 10, '珞': 10, '珊': 9
      // 这里可以继续添加更多常用汉字的笔画数
    };
    const strokeCount = strokeData[char] || 8;
    return strokeCount > 15;
  },
  
  /**
   * 评估名字的字形，满分100分，名字中如果有一个生僻字扣25分，一个复杂字扣25分
   * @param {string} name - 要评估的名字
   * @returns {Object} - 包含分数和分析内容的对象
   */
  evaluateNameShape(name) {
    // 默认结果结构
    const result = {
      score: 0,
      analysis: '',
      details: {
        rareCharCount: 0,
        complexCharCount: 0,
        totalStrokeCount: 0,
        characters: []
      }
    };
    
    // 分析名字中的每个字
    const chars = name.split('');
    console.log(`开始分析名字是否包括生僻字、复杂字: ${name}`);
    
    // 记录生僻字和复杂字
    const rareChars = [];
    const complexChars = [];
    
    // 分析每个字符
    chars.forEach(char => {
      const isRare = this.isRareCharacter(char);
      const isComplex = this.isComplexCharacter(char);
      
      if (isRare) {
        rareChars.push(char);
        result.details.rareCharCount++;
        console.log(`发现生僻字: ${char}`);
      }
      
      if (isComplex) {
        complexChars.push(char);
        result.details.complexCharCount++;
        console.log(`发现复杂字: ${char}`);
      }
      
      result.details.characters.push({
        char,
        isRare,
        isComplex
      });
    });
    
    console.log(`分析结果: 共${result.details.rareCharCount}个生僻字, ${result.details.complexCharCount}个复杂字`);
    console.log(`生僻字: ${rareChars.join(', ')}`);
    console.log(`复杂字: ${complexChars.join(', ')}`);
    
    // 根据生僻字和复杂字的数量计算分数
    const baseScore = 100; // 基础满分100分
    const rareCharPenalty = result.details.rareCharCount * 30; // 每个生僻字扣30分
    const complexCharPenalty = result.details.complexCharCount * 25; // 每个复杂字扣25分
    
    // 计算最终得分，确保不低于0分
    result.score = Math.max(0, baseScore - rareCharPenalty - complexCharPenalty);
    console.log(`字形分数: ${result.score}，基础分${baseScore}，生僻字扣分${rareCharPenalty}，复杂字扣分${complexCharPenalty}`);
    
    // 生成分析文本
    let analysisText = `"${name}"`;
    
    if (result.details.rareCharCount > 0 || result.details.complexCharCount > 0) {
      analysisText += `中`;
      
      if (result.details.rareCharCount > 0) {
        analysisText += `包含${result.details.rareCharCount}个生僻字（${rareChars.join('、')}），不易书写和识别。`;
      }
      
      if (result.details.complexCharCount > 0) {
        analysisText += `包含${result.details.complexCharCount}个复杂字（${complexChars.join('、')}），笔画较多，可能不便于书写。`;
      }
    }
    
    // 根据得分添加评价等级
    if (result.score > 75) {
      analysisText += `字形评价为【优秀】，字形清晰易辨，结构美观，书写方便，识别度高，适合日常使用。`;
      result.gradeClass = 'grade-excellent';
      result.gradeText = '优秀';
    } else if (result.score <= 75 && result.score >= 70) {
      analysisText += `字形评价为【良好】，字形整体较为清晰，有一定的识别度，适合日常使用，但书写时需要多加注意。`;
      result.gradeClass = 'grade-good';
      result.gradeText = '良好';
    } else if (result.score < 70 && result.score >= 40) {
      analysisText += `字形评价为【一般】，字形较为复杂或含有生僻字，可能在日常使用中造成一定的不便，建议考虑替代选择。`;
      result.gradeClass = 'grade-normal';
      result.gradeText = '一般';
    } else {
      analysisText += `字形评价为【较差】，字形过于复杂或含有多个生僻字，不适合日常使用，强烈建议更换其他名字。`;
      result.gradeClass = 'grade-poor';
      result.gradeText = '较差';
    }
    
    result.analysis = analysisText;
    
    console.log(`分析文本: ${result.analysis}`);
    
    // 将字符分析结果保存到全局数据，以便在结果页面显示
    this.setData({
      nameCharAnalysis: result.details.characters
    });
    
    return result;
  },
  
  /**
   * 评估名字与喜用神的匹配度
   */
  evaluateFavElement(favElements, name) {
    // 使用wuxingUtil工具类分析名字与喜用神匹配度
    return wuxingUtil.analyzeNameWuxingMatch(name, favElements)
      .then(result => {
        // 规范化选择的喜用神元素
        const normalizedFavElements = favElements.map(el => el.trim());
        
        // 为每个字符设置匹配状态
        if (result.charElements && result.charElements.length > 0) {
          result.charElements.forEach(charItem => {
            const normalizedElement = charItem.element.trim();
            charItem.isMatch = normalizedFavElements.includes(normalizedElement);
          });
        }
        
        return {
          score: result.score,
          charElements: result.charElements,
          analysis: `名字"${name}"中字的五行属性与您选择的喜用神匹配度为${result.score}分。`
        };
      })
      .catch(error => {
        console.error('评估喜用神匹配度出错:', error);
        // 发生错误时返回默认结果
        return {
          score: 0,
          charElements: [],
          analysis: '分析过程出现错误，请重试。'
        };
      });
  },
  
  /**
   * 计算名字总分
   */
  calculateScore() {
    // 直接开始计算分数流程，无需弹窗确认（已在goToNextStep中确认）
    this.startScoreCalculation();
  },

  // 开始计算分数流程
  startScoreCalculation() {
    // 重置状态
    this.setData({
      isCalculating: true,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });

    // 显示初始加载动画 - 确保mask为false允许点击
    wx.showLoading({
      title: '正在计算分数\n请耐心等待...',
      mask: false
    });
    
    // 开始播放激励广告
    this.showRewardedVideoAd();
    // 启动提示消息循环显示
    this.showMessages(true);
    
    // 准备开始原有的分数计算逻辑，但修改为异步方式
    this.performScoreCalculation()
      .then(result => {
        // 保存API结果
        this.setData({
          apiCompleted: true,
          apiResult: result
        });
        
        // 如果广告已完成，立即停止提示消息
        if (this.data.adCompleted) {
          this.showMessages(false);
        }
        
        // 检查是否可以显示结果页
        this.checkNavigationConditions();
      })
      .catch(error => {
        console.error('计算分数失败:', error);
        this.setData({
          isCalculating: false,
          apiCompleted: true
        });
        
        // 无论成功失败都应该停止提示消息
        this.showMessages(false);
      });

  },

  // 执行分数计算的实际逻辑（原calculateScore方法的内容）
  performScoreCalculation() {
    return new Promise((resolve, reject) => {
      try {
        // 各维度评分
        let dimensionScores = [];
        
        // 1. 姓名
        const name = this.data.name;
        
        // 2. 性别
        const gender = this.data.gender;

        // 3. 姓氏
        const surname = this.data.surname;

        // 4. 名字
        const givenName = this.data.givenName;
        
        // 3. 喜用神
        const favElements = this.data.selectedElements;
        
        // 4. 选择的维度及排序
        const selectedDimensions = this.data.selectedDimensions;
        const dimensionMap = this.data.dimensionMap;
        
        // 5. 各维度权重
        let totalWeight = 0;
        selectedDimensions.forEach(id => {
          totalWeight += dimensionMap[id].weight;
        });
        
        // 处理需要同步计算的维度
        const processSyncDimensions = () => {
          if (selectedDimensions.includes('shape')) {
            const shapeResult = this.evaluateNameShape(givenName);
            dimensionScores.push({
              id: 'shape',
              name: '字形',
              score: shapeResult.score,
              icon: '📝',
              weight: dimensionMap.shape.weight,
              analysis: shapeResult.analysis,
              gradeText: this.getGradeText(shapeResult.score),
              gradeClass: this.getGradeClass(shapeResult.score)
            });
          }
        };
        
        // 处理同步维度
        processSyncDimensions();
        
        // 设置需要处理的异步任务列表
        const asyncTasks = [];
        
        // 处理API调用维度
        const apiParams = {
          name: name,
          sex: gender,
          mean: selectedDimensions.includes('meaning'),
          voice: selectedDimensions.includes('pronunciation'),
          gender: selectedDimensions.includes('gender')
        };
        
        // 如果需要API分析，添加API调用任务
        if (apiParams.mean || apiParams.voice || apiParams.gender) {
          const apiTask = nameApi.nameAnalysis(apiParams)
            .then(response => {
              // 处理发音分析结果
              if (apiParams.voice && response.voiceoutput) {
                const voiceData = nameApi.parsePronunciationResult(response.voiceoutput);
                if (voiceData) {
                  dimensionScores.push({
                    id: 'pronunciation',
                    name: '发音',
                    score: voiceData.totalScore,
                    icon: '🔊',
                    weight: dimensionMap.pronunciation.weight,
                    analysis: `"${name}"${voiceData.suggestions}`,
                    initialsAnalysis: voiceData.initialsAnalysis,
                    initialsScore: voiceData.initialsScore,
                    finalsAnalysis: voiceData.finalsAnalysis,
                    finalsScore: voiceData.finalsScore,
                    homophonyAnalysis: voiceData.homophonyAnalysis,
                    homophonyScore: voiceData.homophonyScore,
                    toneAnalysis: voiceData.toneAnalysis,
                    toneScore: voiceData.toneScore
                  });
                }
              }
              
              // 处理寓意分析结果
              if (apiParams.mean && response.meanoutput) {
                const meaningData = nameApi.parseMeaningResult(response.meanoutput);
                if (meaningData) {
                  dimensionScores.push({
                    id: 'meaning',
                    name: '寓意',
                    score: Math.round(meaningData.score * 10), // 转换为百分制
                    icon: '💭',
                    weight: dimensionMap.meaning.weight,
                    analysis: meaningData.meaning,
                    source: meaningData.source,
                    quote: meaningData.quote,
                    poem: meaningData.poem
                  });
                }
              }
              
              // 处理性别匹配度分析结果
              if (apiParams.gender && response.sexoutput) {
                const genderData = nameApi.parseGenderMatchResult(response.sexoutput);
                if (genderData) {
                  dimensionScores.push({
                    id: 'gender',
                    name: '性别匹配度',
                    score: genderData.matchScore,
                    icon: '⚧',
                    weight: dimensionMap.gender.weight,
                    analysis: genderData.reason
                  });
                }
              }
            })
            .catch(error => {
              console.error('API调用失败:', error);
              // API失败时使用默认数据
              this.handleApiFailure(dimensionScores, dimensionMap, selectedDimensions, name, gender);
            });
          
          asyncTasks.push(apiTask);
        } else {
          // 如果没有API调用，使用默认数据
          this.handleApiFailure(dimensionScores, dimensionMap, selectedDimensions, name, gender);
        }
        
        // 处理喜用神维度（异步）
        if (selectedDimensions.includes('favElement')) {
          const favElementTask = this.evaluateFavElement(favElements, givenName)
            .then(favElementResult => {
              dimensionScores.push({
                id: 'favElement',
                name: '喜用神匹配',
                score: favElementResult.score,
                icon: '🧿',
                weight: dimensionMap.favElement.weight,
                analysis: favElementResult.analysis,
                charElements: favElementResult.charElements
              });
            });
          
          asyncTasks.push(favElementTask);
        }
        
        // 等待所有异步任务完成
        Promise.all(asyncTasks)
          .then(() => {
            // 排序维度分数，按用户选择的优先级
            dimensionScores.sort((a, b) => {
              const indexA = selectedDimensions.indexOf(a.id);
              const indexB = selectedDimensions.indexOf(b.id);
              return indexA - indexB;
            });
            
            // 计算加权总分
            let totalScore = 0;
            dimensionScores.forEach(item => {
              totalScore += (item.score * (item.weight / totalWeight));
            });
            
            // 四舍五入总分
            totalScore = Math.round(totalScore);
            
            // 确保在喜用神维度中添加用户选择的喜用神元素
            if (selectedDimensions.includes('favElement')) {
              const favElementObj = dimensionScores.find(item => item.id === 'favElement');
              if (favElementObj) {
                favElementObj.userElements = this.data.selectedElements;
              }
            }
            
            // 生成总体分析和建议
            const analysis = this.generateAnalysis(dimensionScores);
            const suggestion = this.generateSuggestion(totalScore);
            
            // 创建结果对象
            const result = {
              score: totalScore,
              dimensionScores,
              analysis,
              suggestion
            };
            
            // 为每次测名生成唯一的会话ID，用以区分不同的测名结果
            const currentNameSession = `${this.data.name}_${Date.now()}`;
            
            // 更新当前会话标识，并重置详情广告状态
            this.setData({
              currentNameSession,
              detailAdCompleted: false
            });
            
            // 完成Promise
            resolve(result);
          })
          .catch(error => {
            console.error('计算分数过程中出错:', error);
            reject(error);
          });
      } catch (error) {
        console.error('计算分数出错:', error);
        reject(error);
      }
    });
  },

  // 检查是否满足导航条件
  checkNavigationConditions() {
    if (this.data.adCompleted && this.data.apiCompleted && this.data.apiResult) {
      // 确保消息循环已关闭
      this.showMessages(false);
      
      // 设置结果并显示
      this.setData({
        result: this.data.apiResult,
        currentStep: 'result',
        isCalculating: false
      });
      
      // 关闭加载提示
      wx.hideLoading();
    } else if (this.data.adCompleted && this.data.apiCompleted && !this.data.apiResult) {
      // API返回为空但已经完成，可能出现了错误
      console.error('API已完成但结果为空，可能出现了错误');
      
      // 确保消息循环已关闭
      this.showMessages(false);
      
      // 重置计算状态
      this.setData({
        isCalculating: false
      });
      
      // 关闭加载提示
      wx.hideLoading();
      
      // 显示错误提示
      wx.showModal({
        title: '测算失败',
        content: '很抱歉，名字分析过程出现错误。请稍后重试或联系客服。',
        showCancel: false
      });
    }
  },

  // 取消分数计算
  cancelScoreCalculation() {
    // 重置状态
    this.setData({
      isCalculating: false,
      adCompleted: false,
      apiCompleted: false,
      apiResult: null
    });
    
    // 关闭所有提示
    this.showMessages(false);
    
    try {
      wx.hideToast();
    } catch (e) {
      console.error('hideToast error:', e);
    }
    
    try {
      wx.hideLoading();
    } catch (e) {
      console.error('hideLoading error:', e);
    }
  },

  // 循环显示提示消息的方法
  showMessages(isShow) {
    // 清除可能存在的旧定时器
    if (this.data.messageTimers && this.data.messageTimers.firstTimer) {
      clearTimeout(this.data.messageTimers.firstTimer);
    }
    
    if (this.data.messageTimers && this.data.messageTimers.interval) {
      clearInterval(this.data.messageTimers.interval);
    }
    
    if (!isShow) {
      // 如果不需要显示消息，直接返回
      return;
    }
    
    // 使用名字分析的特定提示消息
    const scoreCalculationMessages = [
      "正在分析名字音律...",
      "正在计算字形评分...",
      "正在查询名字寓意...",
      "正在评估性别匹配度...",
      "正在计算五行属性...",
      "正在整合多维度数据...",
      "正在生成分析报告...",
      "请稍等，马上就好..."
    ];
    
    let messageIndex = 0;
    
    const showCalculationMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示 - 设置mask为false，让用户可以点击其他元素
      wx.showToast({
        title: scoreCalculationMessages[messageIndex],
        icon: 'none',
        duration: 10000,
        mask: false
      });
      
      // 更新消息索引，循环使用提示
      messageIndex = (messageIndex + 1) % scoreCalculationMessages.length;
    };
    
    // 3秒后显示第一次提示
    const firstTimer = setTimeout(() => {
      if (this.data.isCalculating) {
        showCalculationMessage();
      }
    }, 3000);
    
    // 每4秒更新一次提示，直到请求完成
    const interval = setInterval(() => {
      if (this.data.isCalculating) {
        showCalculationMessage();
      } else {
        clearInterval(interval);
      }
    }, 4000);
    
    // 保存定时器引用
    this.setData({
      messageTimers: {
        firstTimer: firstTimer,
        interval: interval
      }
    });
  },

  // 创建激励广告实例
  createRewardedVideoAd() {
    // 创建广告实例
    if (wx.createRewardedVideoAd) {
      this.rewardedVideoAd = wx.createRewardedVideoAd({
        adUnitId: 'adunit-9e4cf424d63967f5'
      });

      // 监听广告加载事件
      this.rewardedVideoAd.onLoad(() => {
        console.log('激励广告加载成功');
      });

      // 监听广告错误事件
      this.rewardedVideoAd.onError((err) => {
        console.error('激励广告出错:', err);
        
        // 立即关闭消息提示
        this.showMessages(false);
        
        // 广告拉取异常视为播放完毕
        this.setData({
          adCompleted: true
        });
        
        // 检查是否可以导航到结果页
        this.checkNavigationConditions();
      });

      // 监听广告关闭事件
      this.rewardedVideoAd.onClose((res) => {
        console.log('激励广告关闭', res);

        // 立即关闭消息提示
        this.showMessages(false);
        
        // 判断是否是正常关闭(用户看完了广告)
        if (res && res.isEnded) {
          console.log('激励广告完整观看');
          this.setData({
            adCompleted: true
          });
          
          // 检查是否可以导航到结果页
          this.checkNavigationConditions();
        } else {
          console.log('激励广告提前关闭');
          // 提示用户广告未播放完毕
          wx.showModal({
            title: '提示',
            content: '广告未播放完毕，无法计算分数，是否继续播放？',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确定，继续播放广告
                this.showRewardedVideoAd(); // 重新播放广告
              } else {
                // 用户点击取消，中断分数计算流程
                this.cancelScoreCalculation();
              }
            }
          });
        }
      });
    }
  },

  // 显示激励广告
  showRewardedVideoAd() {
    console.log('尝试显示激励广告');
    
    // 添加安全超时，防止广告加载无限等待
    const adSafetyTimeout = setTimeout(() => {
      console.log('广告加载超时，自动视为完成');
      // 超时后自动视为广告已完成
      this.setData({
        adCompleted: true
      });
      
      // 检查是否可以导航到结果页
      this.checkNavigationConditions();
      
      // 确保清除加载提示
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
    }, 15000); // 15秒超时
    
    if (this.rewardedVideoAd) {
      this.rewardedVideoAd.show()
        .catch(err => {
          console.log('激励广告显示失败，尝试重新加载:', err);
          
          // 失败重试
          this.rewardedVideoAd.load()
            .then(() => {
              console.log('激励广告重新加载成功，再次尝试显示');
              return this.rewardedVideoAd.show();
            })
            .then(() => {
              // 广告显示成功，清除超时定时器
              clearTimeout(adSafetyTimeout);
            })
            .catch(loadError => {
              console.error('激励广告重新加载失败，跳过广告:', loadError);
              // 重新加载也失败，直接设置为完成状态
              clearTimeout(adSafetyTimeout);
              this.setData({
                adCompleted: true
              });
              
              // 检查是否可以导航到结果页
              this.checkNavigationConditions();
              
              // 确保清除加载提示
              try {
                wx.hideLoading();
              } catch (e) {
                console.error('hideLoading error:', e);
              }
            });
        })
        .then(() => {
          // 广告显示成功，清除超时定时器
          clearTimeout(adSafetyTimeout);
        });
    } else {
      console.log('激励广告实例不存在，直接视为完成');
      // 不支持广告或实例不存在，直接设置为完成状态
      clearTimeout(adSafetyTimeout);
      this.setData({
        adCompleted: true
      });
      
      // 检查是否可以导航到结果页
      this.checkNavigationConditions();
    }
  },

  /**
   * 生成分析内容
   */
  generateAnalysis(dimensionScores) {
    // 简化：实际应用中应根据名字特点和维度得分生成详细分析
    const analysis = [];
    
    dimensionScores.forEach(item => {
      let content = '';
      
      switch(item.id) {
        case 'pronunciation':
          content = `"${this.data.name}"发音${item.score >= 90 ? '优美' : item.score >= 80 ? '良好' : '一般'}，声调搭配和谐，朗朗上口。无不良谐音，整体发音流畅自然。`;
          break;
        case 'shape':
          content = item.analysis;
          break;
        case 'meaning':
          content = `"${this.data.name}"寓意${item.score >= 90 ? '深远' : item.score >= 80 ? '美好' : '一般'}，展现出积极向上的特质。暗示人聪明智慧、有条理性。`;
          break;
        case 'favElement':
          content = item.analysis;
          break;
        case 'gender':
          content = `"${this.data.name}"对于${this.data.gender}性而言${item.score >= 90 ? '非常适合' : item.score >= 80 ? '比较适合' : '基本适合'}，符合现代${this.data.gender}性的特征，给人留下良好印象。`;
          break;
      }
      
      analysis.push({
        title: item.name + '分析',
        content,
        icon: item.icon
      });
    });
    
    return analysis;
  },
  
  /**
   * 生成名字建议
   */
  generateSuggestion(score) {
    // 根据总分生成建议
    if (score >= 90) {
      return `"${this.data.name}"是一个非常优秀的名字选择，各方面评分都很高。这个名字寓意美好，发音流畅，字形美观，契合命理，性别匹配度高。建议您可以放心使用此名，它将为您的未来带来积极的影响。`;
    } else if (score >= 80) {
      return `"${this.data.name}"是一个不错的名字选择，总体评分较高。这个名字在多个方面表现良好，但仍有小幅提升空间。总体而言，这是一个值得考虑的好名字。`;
    } else if (score >= 70) {
      return `"${this.data.name}"是一个基本可用的名字，但在某些维度上还有提升空间。您可以考虑使用此名，也可以继续寻找评分更高的选择。`;
    } else {
      return `"${this.data.name}"在某些关键维度上表现欠佳，建议您重新考虑或调整此名，以获得更适合的名字选择。`;
    }
  },

  /**
   * 分享测名结果
   */
  onShareAppMessage() {
    return {
      title: `我在"名字打分"测算了「${this.data.name}」，得分${this.data.result.score}分！`,
      path: '/pages/nametest/nametest'
    };
  },

  /**
   * 切换维度详情显示
   */
  toggleDimensionDetail(e) {
    const id = e.currentTarget.dataset.id;
    
    // 获取当前维度的展开状态
    const dimensionScores = this.data.result.dimensionScores;
    const index = dimensionScores.findIndex(item => item.id === id);
    
    if (index > -1) {
      // 如果已经展开，则收起
      if (dimensionScores[index].showDetail) {
        this.showDimensionDetail(id);
        return;
      }
      
      // 从本地存储获取已完成广告的会话ID列表
      let completedSessions = wx.getStorageSync('detailAdCompletedSessions') || [];
      
      // 检查当前会话是否已观看过广告
      if (!this.data.detailAdCompleted && !completedSessions.includes(this.data.currentNameSession)) {
        // 保存待处理的详情ID
        this.setData({
          pendingDetailId: id
        });
        
        // 提示用户将播放广告
        wx.showModal({
          title: '详情分析',
          content: '✨ 为了提供更专业的分析服务，邀请您观看一小段广告，完成后即可查看本次测名的所有维度详情分析。感谢您的支持，这帮助我们持续优化服务质量！',
          success: (res) => {
            if (res.confirm) {
              // 用户同意观看广告
              this.showDetailRewardedVideoAd();
            } else {
              // 用户拒绝观看广告，清空待处理ID
              this.setData({
                pendingDetailId: null
              });
            }
          }
        });
      } else {
        // 已观看过广告，直接显示详情
        this.showDimensionDetail(id);
      }
    }
  },

  // 在JS中添加辅助方法
  getGradeClass(score) {
    if (score > 75) return 'grade-excellent';
    if (score <= 75 && score >= 70) return 'grade-good';
    if (score < 70 && score >= 40) return 'grade-normal';
    return 'grade-poor';
  },

  getGradeText(score) {
    if (score > 75) return '优秀';
    if (score <= 75 && score >= 70) return '良好';
    if (score < 70 && score >= 40) return '一般';
    return '较差';
  },

  /**
   * 处理API调用失败的情况，使用默认数据
   */
  handleApiFailure(dimensionScores, dimensionMap, selectedDimensions, name, gender) {
    // 发音维度默认数据
    if (selectedDimensions.includes('pronunciation') && !dimensionScores.find(item => item.id === 'pronunciation')) {
      const pronunciationScore = 85;
      dimensionScores.push({
        id: 'pronunciation',
        name: '发音',
        score: pronunciationScore,
        icon: '🔊',
        weight: dimensionMap.pronunciation.weight,
        analysis: `"${name}"发音优美，整体发音流畅自然，没有发现不良谐音。`,
        initialsAnalysis: "声母组合和谐",
        initialsScore: 85,
        finalsAnalysis: "韵母搭配优美",
        finalsScore: 90,
        homophonyAnalysis: "无不良谐音",
        homophonyScore: 95,
        toneAnalysis: "声调变化适中",
        toneScore: 80
      });
    }
    
    // 寓意维度默认数据
    if (selectedDimensions.includes('meaning') && !dimensionScores.find(item => item.id === 'meaning')) {
      const meaningScore = 90;
      dimensionScores.push({
        id: 'meaning',
        name: '寓意',
        score: meaningScore,
        icon: '💭',
        weight: dimensionMap.meaning.weight,
        analysis: `"${name}"寓意美好，表达了积极向上的含义。`,
        source: "《诗经》",
        quote: "温柔敦厚，诗教也。",
        poem: "关关雎鸠，在河之洲。窈窕淑女，君子好逑。"
      });
    }
    
    // 性别匹配度维度默认数据
    if (selectedDimensions.includes('gender') && !dimensionScores.find(item => item.id === 'gender')) {
      const genderScore = 88;
      dimensionScores.push({
        id: 'gender',
        name: '性别匹配度',
        score: genderScore,
        icon: '⚧',
        weight: dimensionMap.gender.weight,
        analysis: `"${name}"这个名字与${gender}性特质匹配度较高，给人以符合性别气质的印象。`
      });
    }
  },

  // 创建详情查看激励广告实例
  createDetailRewardedVideoAd() {
    // 创建广告实例
    if (wx.createRewardedVideoAd) {
      this.detailRewardedVideoAd = wx.createRewardedVideoAd({
        adUnitId: 'adunit-754e505d1c688e21'
      });

      // 监听广告加载事件
      this.detailRewardedVideoAd.onLoad(() => {
        console.log('详情查看激励广告加载成功');
      });

      // 监听广告错误事件
      this.detailRewardedVideoAd.onError((err) => {
        console.error('详情查看激励广告出错:', err);
        // 广告拉取异常视为播放完毕
        this.setData({
          detailAdCompleted: true
        });
        
        // 如果有待处理的详情ID，直接显示详情
        if (this.data.pendingDetailId) {
          this.showDimensionDetail(this.data.pendingDetailId);
        }
      });

      // 监听广告关闭事件
      this.detailRewardedVideoAd.onClose((res) => {
        console.log('详情查看激励广告关闭', res);

        // 判断是否是正常关闭(用户看完了广告)
        if (res && res.isEnded) {
          console.log('详情查看激励广告完整观看');
          
          // 标记当前广告已完成
          this.setData({
            detailAdCompleted: true
          });
          
          // 将当前会话添加到本地存储中的已完成会话列表
          let completedSessions = wx.getStorageSync('detailAdCompletedSessions') || [];
          if (!completedSessions.includes(this.data.currentNameSession)) {
            completedSessions.push(this.data.currentNameSession);
            wx.setStorageSync('detailAdCompletedSessions', completedSessions);
          }
          
          // 如果有待处理的详情ID，显示详情
          if (this.data.pendingDetailId) {
            this.showDimensionDetail(this.data.pendingDetailId);
          }
        } else {
          console.log('详情查看激励广告提前关闭');
          // 提示用户广告未播放完毕
          wx.showModal({
            title: '提示',
            content: '需要完整观看广告才能查看详情分析，是否继续？',
            success: (res) => {
              if (res.confirm) {
                // 用户点击确定，继续播放广告
                this.showDetailRewardedVideoAd();
              } else {
                // 用户点击取消，清空待处理ID
                this.setData({
                  pendingDetailId: null
                });
              }
            }
          });
        }
      });
    }
  },

  // 显示详情查看激励广告
  showDetailRewardedVideoAd() {
    console.log('尝试显示详情查看激励广告');
    
    if (this.detailRewardedVideoAd) {
      this.detailRewardedVideoAd.show()
        .catch(err => {
          console.log('详情查看激励广告显示失败，尝试重新加载:', err);
          
          // 失败重试
          wx.showLoading({
            title: '加载广告中...',
            mask: false
          });
          
          return this.detailRewardedVideoAd.load()
            .then(() => {
              wx.hideLoading();
              console.log('重新加载详情广告成功，尝试再次显示');
              return this.detailRewardedVideoAd.show();
            })
            .catch(err => {
              wx.hideLoading();
              console.error('详情查看激励广告重新加载失败:', err);
              
              // 广告显示异常视为播放完毕
              this.setData({
                detailAdCompleted: true
              });
              
              // 如果有待处理的详情ID，直接显示详情
              if (this.data.pendingDetailId) {
                this.showDimensionDetail(this.data.pendingDetailId);
              }
              
              // 显示提示
              wx.showToast({
                title: '广告加载失败，直接查看详情',
                icon: 'none',
                duration: 2000
              });
            });
        });
    } else {
      console.error('详情查看激励广告实例不存在');
      
      // 如果广告实例不存在，视为广告完成
      this.setData({
        detailAdCompleted: true
      });
      
      // 如果有待处理的详情ID，直接显示详情
      if (this.data.pendingDetailId) {
        this.showDimensionDetail(this.data.pendingDetailId);
      }
    }
  },
  
  // 显示维度详情
  showDimensionDetail(id) {
    const dimensionScores = this.data.result.dimensionScores;
    const index = dimensionScores.findIndex(item => item.id === id);
    
    // 如果是喜用神维度，确保有userElements字段
    if (id === 'favElement' && (!dimensionScores[index].userElements || !dimensionScores[index].userElements.length)) {
      dimensionScores[index].userElements = this.data.selectedElements;
      
      // 确保字符元素和用户选择的元素格式一致
      if (dimensionScores[index].charElements && dimensionScores[index].charElements.length > 0) {
        // 打印调试信息
        console.log('选择的元素:', this.data.selectedElements);
        console.log('字符元素:', dimensionScores[index].charElements);
        
        // 规范化元素格式，确保大小写和空格一致
        const normalizedSelectedElements = this.data.selectedElements.map(el => el.trim());
        
        // 遍历每个字符元素，重新计算匹配状态
        dimensionScores[index].charElements.forEach(charItem => {
          // 规范化字符元素
          const normalizedElement = charItem.element.trim();
          
          // 设置匹配状态
          charItem.isMatch = normalizedSelectedElements.includes(normalizedElement);
          
          console.log(`字符 ${charItem.char} 的五行: ${normalizedElement}, 匹配状态: ${charItem.isMatch}`);
        });
      }
    }
    
    if (index > -1) {
      const showDetail = !dimensionScores[index].showDetail;
      
      this.setData({
        [`result.dimensionScores[${index}].showDetail`]: showDetail
      });
    }
  },

  /**
   * 页面卸载时清理资源
   */
  onUnload() {
    // 清理消息定时器
    this.showMessages(false);
    
    // 清理广告相关资源
    if (this.rewardedVideoAd) {
      try {
        // 尝试销毁广告实例，不是所有小程序版本都支持此方法
        if (typeof this.rewardedVideoAd.destroy === 'function') {
          this.rewardedVideoAd.destroy();
        }
      } catch (e) {
        console.error('销毁广告实例失败:', e);
      }
    }
    
    // 清理详情查看广告实例
    if (this.detailRewardedVideoAd) {
      try {
        // 尝试销毁广告实例
        if (typeof this.detailRewardedVideoAd.destroy === 'function') {
          this.detailRewardedVideoAd.destroy();
        }
      } catch (e) {
        console.error('销毁详情查看广告实例失败:', e);
      }
    }
  }
}) 